package com.crm.CLdriving.util.Thread;


import java.util.LinkedList;  
import java.util.Queue;  
import java.util.concurrent.ArrayBlockingQueue;  
import java.util.concurrent.Executors;  
import java.util.concurrent.RejectedExecutionHandler;  
import java.util.concurrent.ScheduledExecutorService;  
import java.util.concurrent.ScheduledFuture;  
import java.util.concurrent.ThreadPoolExecutor;  
import java.util.concurrent.TimeUnit;  
  
/** 
 * 线程池管理 
 */  
public class ThreadPoolManager {  
   
 private static ThreadPoolManager tpm = new ThreadPoolManager();  
  
 // 线程池维护线程的最少数量  
 private final static int CORE_POOL_SIZE = 3;  
  
 // 线程池维护线程的最大数量  
 private final static int MAX_POOL_SIZE = 70;  
  
 // 线程池维护线程所允许的空闲时间  
 private final static int KEEP_ALIVE_TIME = 0;  
  
 // 线程池所使用的缓冲队列大小  
 private final static int WORK_QUEUE_SIZE = 20;  
  
 // 任务调度周期  
 private final static int TASK_QOS_PERIOD = 10;  
  
 // 任务缓冲队列  
 private Queue<Runnable> taskQueue = new LinkedList<Runnable>();  
  
 /* 
  * 线程池超出界线时将任务加入缓冲队列 
  */  
 final RejectedExecutionHandler handler = new RejectedExecutionHandler() {  
  public void rejectedExecution(Runnable task, ThreadPoolExecutor executor) {  
   taskQueue.offer(task);  
  }  
 };  
  
 /* 
  * 将缓冲队列中的任务重新加载到线程池 
  */  
 final Runnable accessBufferThread = new Runnable() {  
  public void run() {  
   if (hasMoreAcquire()) {  
    threadPool.execute(taskQueue.poll());  
   }  
  }  
 };  
  
 /* 
  * 创建一个调度线程池 
  */  
 final ScheduledExecutorService scheduler = Executors  
   .newScheduledThreadPool(1);  
  
 /* 
  * 通过调度线程周期性的执行缓冲队列中任务 
  */  
 final ScheduledFuture<?> taskHandler = scheduler.scheduleAtFixedRate(  
   accessBufferThread, 0, TASK_QOS_PERIOD, TimeUnit.MILLISECONDS);  
  
 /* 
  * 线程池 
  */  
 final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(  
   CORE_POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIVE_TIME, TimeUnit.SECONDS,  
   new ArrayBlockingQueue<Runnable>(WORK_QUEUE_SIZE), this.handler);  
  
 /* 
  * 将构造方法访问修饰符设为私有，禁止任意实例化。 
  */  
 private ThreadPoolManager() {  
  
 }  
  
 /* 
  * 线程池单例创建方法 
  */  
 public static ThreadPoolManager newInstance() {  
  return tpm;  
 }  
  
 /* 
  * 消息队列检查方法 
  */  
 private boolean hasMoreAcquire() {  
  return !taskQueue.isEmpty();  
 }  
  
 /* 
  * 向线程池中添加任务方法 
  */  
 public void addExecuteTask(Runnable task) {  
		if (task != null) {
			threadPool.execute(task);
   /*System.out.println("线程池中线程数目："+threadPool.getPoolSize()+"，队列中等待执行的任务数目："+
		   threadPool.getQueue().size()+"，已执行玩别的任务数目："+threadPool.getCompletedTaskCount());*/
		} 
 }  
}  